home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 126-150 / disk_126 / suplib / dio.h < prev    next >
C/C++ Source or Header  |  1992-05-06  |  4KB  |  125 lines
  1.  
  2. /*
  3.  * DIO.H
  4.  *
  5.  *  (C)Copyright 1987 Matthew Dillon, All Rights Reserved
  6.  *  Freely distributable.  Donations welcome, I guess.
  7.  *
  8.  *    Matthew Dillon
  9.  *    891 Regal Rd.
  10.  *    Berkeley, Ca.    94708
  11.  *
  12.  */
  13.  
  14. #ifndef MYLIB_DIO_H
  15. #define MYLIB_DIO_H
  16. #include <exec/types.h>
  17. #include <exec/io.h>
  18. #include <exec/memory.h>
  19. #include <exec/ports.h>
  20. #include <devices/timer.h>
  21.  
  22. typedef struct IORequest IOR;
  23. typedef struct IOStdReq  STD;
  24. typedef struct MsgPort     PORT;
  25.  
  26. /*
  27.  *    'to' is in microsections.  The IO request structure
  28.  *  pointer is optional to dio_open().    If NULL, dio_open()
  29.  *  initializes it's own IO request (to mostly zero).  You have
  30.  *  to provide an IO request structure, for instance, if openning
  31.  *  a console device since the window pointer must be passed to
  32.  *  OpenDevice().
  33.  *
  34.  *    each DFD descriptor has it's own signal.
  35.  *
  36.  *    dio_isdone() returns 1 if the channel is clear, 0 otherwise.
  37.  */
  38.  
  39. extern long dio_open();     /* dfd      = dio_open(devname,unit,flags,req)*/
  40. extern long dio_dup();        /* newdfd = dio_dup(dfd)    */
  41. extern STD *dio_ctl();        /* req    = dio_ctl(dfd,com,buf,len)        */
  42. extern STD *dio_ctl_to();    /* req    = dio_ctl_to(dfd,com,buf,len,to)    */
  43. extern STD *dio_wait();     /* req    = dio_wait(dfd)     */
  44. extern STD *dio_abort();    /* req    = dio_abort(dfd)    */
  45. extern STD *dio_isdone();    /* req    = dio_isdone(dfd)   */
  46. extern int dio_signal();    /* signm= dio_signal(dfd)   */
  47. extern void dio_close();    /*  dio_close(dfd)        */
  48. extern void dio_cloesgroup();    /*  dio_closegroup(dfd)     */
  49. extern void dio_cact();     /*  dio_cact(dfd,bool)        */
  50.  
  51.  
  52.  
  53. /*
  54.  * dio_simple() and related macros return the !io_Error field. That
  55.  * is, 0=ERROR, 1=OK
  56.  *
  57.  * dio_actual() returns the io_Actual field.
  58.  *
  59.  * NOTE: the io_Actual field may not be set by the device if an
  60.  * error condition exists.  To make the io_ctl() and io_ctl_to()
  61.  * call automatically clear the io_Actual field before doing the
  62.  * io operation, use the DIO_CACT() call.  The reason this isn't
  63.  * done automatically by default is that some devices require
  64.  * parameters to be passed in the io_Actual field (like the
  65.  * timer.device).
  66.  *
  67.  *  Remember, Asyncronous IO is done by sending -com instead of com.
  68.  *
  69.  *    CALL                Syncronous IO   Asyncronous IO
  70.  *
  71.  *  dio_simple(dfd,com)         0=ERROR, 1=OK   undefined
  72.  *  dio_actual(dfd,com)         io_Actual        undefined
  73.  *  dio_reset(dfd)            0=ERROR, 1=OK   n/a
  74.  *  dio_update(dfd)            0=ERROR, 1=OK   n/a
  75.  *  dio_clear(dfd)            0=ERROR, 1=OK   n/a
  76.  *  dio_stop(dfd)            0=ERROR, 1=OK   n/a
  77.  *  dio_start(dfd)            0=ERROR, 1=OK   n/a
  78.  *  dio_flush(dfd)            0=ERROR, 1=OK   n/a
  79.  *  dio_getreq(dfd)            returns a ptr to the IO
  80.  *                    request structure
  81.  *  NOTE: If you use the following, you probably want to have the
  82.  *  device library automatically clear the io_Actual field before
  83.  *  sending the request so you get 0 if an error occurs.  That
  84.  *  is: dio_cact(dfd,1);
  85.  *
  86.  *
  87.  *  dio_read(dfd,buf,len)        returns actual bytes read
  88.  *  dio_write(dfd,buf,len)        returns actual bytes written
  89.  *
  90.  *    The timeout argument for dio_readto() and dio_writeto()
  91.  *    is in MICROSECONDS, up to 2^31uS.
  92.  *
  93.  *  dio_readto(dfd,buf,len,to)        returns actual bytes read
  94.  *  dio_writeto(dfd,buf,len,to)     returns actual bytes written
  95.  *
  96.  *    The asyncronous dio_reada() and dio_writea() do not
  97.  *    return anything.
  98.  *
  99.  *  dio_reada(dfd,buf,len)        begin asyncronous read
  100.  *  dio_writea(dfd,buf,len)        begin asyncronous write
  101.  */
  102.  
  103. #define dio_mask(dfd)        (1 << dio_signal(dfd))
  104.  
  105. #define dio_simple(dfd,com)    (!dio_ctl(dfd,com,0,0)->io_Error)
  106. #define dio_actual(dfd,com)    ( dio_ctl(dfd,com,0,0)->io_Actual)
  107. #define dio_reset(dfd)        dio_simple(dfd,CMD_RESET)
  108. #define dio_update(dfd)     dio_simple(dfd,CMD_UPDATE)
  109. #define dio_clear(dfd)        dio_simple(dfd,CMD_CLEAR)
  110. #define dio_stop(dfd)        dio_simple(dfd,CMD_STOP)
  111. #define dio_start(dfd)        dio_simple(dfd,CMD_START)
  112. #define dio_flush(dfd)        dio_simple(dfd,CMD_FLUSH)
  113. #define dio_getreq(dfd)     dio_ctl(dfd,0,0,0)
  114.  
  115. #define dio_read(dfd,buf,len)        (dio_ctl(dfd,CMD_READ,buf,len)->io_Actual)
  116. #define dio_write(dfd,buf,len)        (dio_ctl(dfd,CMD_WRITE,buf,len)->io_Actual)
  117. #define dio_readto(dfd,buf,len,to)  (dio_ctl_to(dfd,CMD_READ,buf,len,to)->io_Actual)
  118. #define dio_writeto(dfd,buf,len,to) (dio_ctl_to(dfd,CMD_WRITE,buf,len,to)->io_Actual)
  119. #define dio_reada(dfd,buf,len)        ((void)dio_ctl(dfd,-CMD_READ,buf,len))
  120. #define dio_writea(dfd,buf,len)     ((void)dio_ctl(dfd,-CMD_WRITE,buf,len))
  121.  
  122. #endif
  123.  
  124.  
  125.